package cn.tedu.truetaste.service.impl;

import cn.tedu.truetaste.ex.ServiceException;
import cn.tedu.truetaste.mapper.DishesMapper;
import cn.tedu.truetaste.pojo.dto.DishesAddNewDTO;
import cn.tedu.truetaste.pojo.dto.DishesUpdateDTO;
import cn.tedu.truetaste.pojo.entity.Dishes;
import cn.tedu.truetaste.pojo.entity.DishesForElastic;
import cn.tedu.truetaste.pojo.entity.Spu;
import cn.tedu.truetaste.pojo.vo.*;
import cn.tedu.truetaste.restful.JsonPage;
import cn.tedu.truetaste.service.IDishesService;
import cn.tedu.truetaste.service.ISkuService;
import cn.tedu.truetaste.service.ISpuService;
import cn.tedu.truetaste.web.ServiceCode;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * 处理菜品业务的实现类
 *
 * @author java@tedu.cn
 * @version 0.0.1
 */

@Slf4j
@Service
public class DishesServiceImpl implements IDishesService {
    @Autowired
    private DishesMapper dishesMapper;

    @Autowired
    private ISkuService skuService;

    @Autowired
    private ISpuService spuService;

    public DishesServiceImpl() {
        log.info("创建业务对象：DishesServiceImpl");
    }

    @Override
    public void addNew(DishesAddNewDTO dishesAddNewDTO) {
        log.debug("开始处理【添加菜品】的业务，参数：{}", dishesAddNewDTO);
        // 调用DishesMapper对象的int countByName(String name)方法统计此名称的菜品的数量
        String  name = dishesAddNewDTO.getName();
        int countByName= dishesMapper.countByName(name);
        // 判断所属菜品名称是否存在
        if (countByName>0) {
            // 是：菜品名称不存在，抛出RuntimeException异常
            String message = "添加菜品失败！菜品已经被占用！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }

        // 准备需要添加到数据库的对象
        Dishes dishes = new Dishes();
        BeanUtils.copyProperties(dishesAddNewDTO, dishes);

        // 执行插入菜品数据
        int rows = dishesMapper.insert(dishes);
        if (rows != 1) {
            String message = "添加菜品失败！服务器忙，请稍后再次尝试！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_INSERT, message);
        }
    }

    @Override
    public void delete(Long id) {
        log.debug("开始处理【删除菜品】的业务，参数：{}", id);
        // 检查尝试删除的菜品是否存在
        Object queryResult = dishesMapper.getStandardById(id);
        if (queryResult == null) {
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, "删除菜品失败，尝试访问的数据不存在！");
        }


        // 执行删除
        int rows = dishesMapper.deleteById(id);
        if (rows != 1) {
            throw new ServiceException(ServiceCode.ERR_DELETE, "删除菜品失败，服务器忙，请稍后再次尝试！");
        }
        log.debug("删除菜品完成！");
    }

    @Override
    public void updateInfoById(Long id, DishesUpdateDTO dishesUpdateDTO) {
        log.debug("开始处理【修改菜品详情】的业务，参数ID：{}，新数据：{}",id, dishesUpdateDTO);

        {
            // 调用Mapper的getStandardById()执行查询，检查数据是否不存在
            DishesStandardVO dishes = dishesMapper.getStandardById(id);
            // 是：数据不存在，抛出异常
            if (dishes == null) {
                String message = "修改菜品详情失败，尝试访问的数据不存在！";
                log.warn(message);
                throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
            }
        }

        {
            // 调用Mapper的countByNameAndNotId()执行查询，检查新的名称是否已经被别的数据占用
            int count = dishesMapper.countByNameAndNotId(id, dishesUpdateDTO.getName());
            // 是：名称被别的数据占用，抛出异常（NOT_CONFLICT）
            if (count > 0) {
                String message = "修改菜品详情失败，新的菜品名称已经被占用！";
                log.warn(message);
                throw new ServiceException(ServiceCode.ERR_CONFLICT, message);
            }
        }

        // 创建Dishes对象
        Dishes dishes = new Dishes();
        // 将参数对象的属性值复制到以上新创建的Dishes对象中
        BeanUtils.copyProperties(dishesUpdateDTO, dishes);
        dishes.setId(id);
        // 调用Mapper的update(Dishes dishes)方法执行修改
        log.debug("即将执行修改数据，参数：{}", dishes);
        int rows = dishesMapper.update(dishes);
        if (rows != 1) {
            String message = "修改菜品详情失败，服务器忙，请稍后再次尝试！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_UPDATE, message);
        }
    }

    @Override
    public DishesStandardVO getStandardById(Long id) {
        log.debug("开始处理【根据id查询菜品详情】的业务，参数：{}", id);

        // 调用Mapper的getStandardById()执行查询
        DishesStandardVO dishes = dishesMapper.getStandardById(id);
        // 判断查询结果是否为null
        // 是：没有匹配的数据，抛出异常（NOT_FOUND）
        if (dishes == null) {
            String message = "查询菜品详情失败，尝试访问的数据不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }

        log.debug("即将返回查询结果：{}", dishes);
        return dishes;
    }

    @Override
    public DishesStandardVO getCategoryId(Long categoryId) {
        log.debug("开始处理【根据类别id查询菜品数据详情】的业务，参数：{}", categoryId);

        // 调用Mapper的getCategoryId()执行查询
        DishesStandardVO dishes = dishesMapper.getCategoryId(categoryId);
        // 判断查询结果是否为null
        // 是：没有匹配的数据，抛出异常（NOT_FOUND）
        if (dishes == null) {
            String message = "查询菜品详情失败，尝试访问的数据不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }

        log.debug("即将返回查询结果：{}", dishes);
        return dishes;
    }

    @Override
    public JsonPage<DishesListItemVO> list(Integer nowPage, Integer pageNum) {
        log.debug("开始处理【查询菜品列表】的业务，页码{}，每页条数{}",nowPage,pageNum);
        PageHelper.startPage(nowPage,pageNum);
        List<DishesListItemVO> list = dishesMapper.list();
        log.debug("即将返回查询结果：{}", list);
        return JsonPage.restPage(new PageInfo<>(list));
    }

//    @Override
//    public List<DishesListItemVO> list() {
//        log.debug("开始处理【查询菜品列表】的业务，无参数");
//        List<DishesListItemVO> list = dishesMapper.list();
//        log.debug("即将返回查询结果：{}", list);
//        return list;
//    }

    // 根据分类id分页查询spu列表
    @Override
    public JsonPage<SpuListItemVO> listSpuByCategoryId(Long categoryId, Integer page, Integer pageSize) {
        JsonPage<SpuListItemVO> jsonPage=spuService.listSpuByCategoryId(categoryId, page, pageSize);
        return jsonPage;
    }

    // 根据spuId查询spu信息
    @Override
    public SpuStandardVO getSpuById(Long id) {
        SpuStandardVO spuStandardVO=spuService.getSpuById(id);
        return spuStandardVO;
    }

    // 根据spuId查询sku列表
    @Override
    public List<SkuStandardVO> getSkusBySpuId(Long spuId) {
        List<SkuStandardVO> list=skuService.getSkusBySpuIdS(spuId);
        return list;
    }

    // 根据spuId查询spu商品detail
    @Override
    public SpuDetailStandardVO getSpuDetail(Long spuId) {
        SpuDetailStandardVO spuDetailStandardVO=spuService.getSpuDetailById(spuId);
        return spuDetailStandardVO;
    }

    @Override
    public JsonPage<DishesForElastic> getSpuByPage(Integer pageNum, Integer pageSize) {
        PageHelper.startPage(pageNum,pageSize);
        List<DishesForElastic> list=dishesMapper.findAllList();
        return JsonPage.restPage(new PageInfo<>(list));
    }

    @Override
    public List<DishesListItemVO> listBySpuDetailId(Long spuDetailId) {
        log.debug("开始处理【根据菜品id查询spuDetail列表】的业务，参数：{}", spuDetailId);
        return dishesMapper.listBySpuDetailId(spuDetailId);
    }

}
